sdk/samples/all in on code/Visual Studio 2008/CppAutomateOutlook/Solution2.cpp

   1 /****************************** Module Header ******************************\
   2 * Module Name:  Solution2.cpp
   3 * Project:      CppAutomateOutlook
   4 * Copyright (c) Microsoft Corporation.
   5 *
   6 * The code in Solution2.h/cpp demontrates the use of C/C++ and the COM APIs
   7 * to automate Outlook. The raw automation is much more difficult, but it is
   8 * sometimes necessary to avoid the overhead with MFC, or problems with
   9 * #import. Basically, you work with such APIs as CoCreateInstance(), and COM
  10 * interfaces such as IDispatch and IUnknown.
  11 *
  12 * This source is subject to the Microsoft Public License.
  13 * See http://www.microsoft.com/opensource/licenses.mspx#Ms-PL.
  14 * All other rights reserved.
  15 *
  16 * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
  17 * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
  18 * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
  19 \***************************************************************************/
  20
  21 #pragma region Includes
  22 #include <stdio.h>
  23 #include <windows.h>
  24 #include "Solution2.h"
  25 #pragma endregion
  26
  27
  28 //
  29 //   FUNCTION: AutoWrap(int, VARIANT*, IDispatch*, LPOLESTR, int,...)
  30 //
  31 //   PURPOSE: Automation helper function. It simplifies most of the low-level
  32 //      details involved with using IDispatch directly. Feel free to use it
  33 //      in your own implementations. One caveat is that if you pass multiple
  34 //      parameters, they need to be passed in reverse-order.
  35 //
  36 //   PARAMETERS:
  37 //      * autoType - Could be one of these values: DISPATCH_PROPERTYGET,
  38 //      DISPATCH_PROPERTYPUT, DISPATCH_PROPERTYPUTREF, DISPATCH_METHOD.
  39 //      * pvResult - Holds the return value in a VARIANT.
  40 //      * pDisp - The IDispatch interface.
  41 //      * ptName - The property/method name exposed by the interface.
  42 //      * cArgs - The count of the arguments.
  43 //
  44 //   RETURN VALUE: An HRESULT value indicating whether the function succeeds
  45 //      or not.
  46 //
  47 //   EXAMPLE:
  48 //      AutoWrap(DISPATCH_METHOD, NULL, pDisp, L"call", 2, parm[1], parm[0]);
  49 //
  50 HRESULT AutoWrap(int autoType, VARIANT *pvResult, IDispatch *pDisp,
  51                                  LPOLESTR ptName, int cArgs...)
  52 {
  53         // Begin variable-argument list
  54         va_list marker;
  55         va_start(marker, cArgs);
  56
  57         if (!pDisp)
  58         {
  59                 _putws(L"NULL IDispatch passed to AutoWrap()");
  60                 _exit(0);
  61                 return E_INVALIDARG;
  62         }
  63
  64         // Variables used
  65         DISPPARAMS dp = { NULL, NULL, 0, 0 };
  66         DISPID dispidNamed = DISPID_PROPERTYPUT;
  67         DISPID dispID;
  68         HRESULT hr;
  69
  70         // Get DISPID for name passed
  71         hr = pDisp->GetIDsOfNames(IID_NULL, &ptName, 1, LOCALE_USER_DEFAULT, &dispID);
  72         if (FAILED(hr))
  73         {
  74                 wprintf(L"IDispatch::GetIDsOfNames(\"%s\") failed w/err 0x%08lx\n",
  75                         ptName, hr);
  76                 _exit(0);
  77                 return hr;
  78         }
  79
  80         // Allocate memory for arguments
  81         VARIANT *pArgs = new VARIANT[cArgs + 1];
  82         // Extract arguments...
  83         for(int i=0; i < cArgs; i++)
  84         {
  85                 pArgs[i] = va_arg(marker, VARIANT);
  86         }
  87
  88         // Build DISPPARAMS
  89         dp.cArgs = cArgs;
  90         dp.rgvarg = pArgs;
  91
  92         // Handle special-case for property-puts
  93         if (autoType & DISPATCH_PROPERTYPUT)
  94         {
  95                 dp.cNamedArgs = 1;
  96                 dp.rgdispidNamedArgs = &dispidNamed;
  97         }
  98
  99         // Make the call
 100         hr = pDisp->Invoke(dispID, IID_NULL, LOCALE_SYSTEM_DEFAULT,
 101                 autoType, &dp, pvResult, NULL, NULL);
 102         if (FAILED(hr))
 103         {
 104                 wprintf(L"IDispatch::Invoke(\"%s\"=%08lx) failed w/err 0x%08lx\n",
 105                         ptName, dispID, hr);
 106                 _exit(0);
 107                 return hr;
 108         }
 109
 110         // End variable-argument section
 111         va_end(marker);
 112
 113         delete[] pArgs;
 114
 115         return hr;
 116 }
 117
 118
 119 DWORD WINAPI AutomateOutlookByCOMAPI(LPVOID lpParam)
 120 {
 121         // Initializes the COM library on the current thread and identifies
 122         // the concurrency model as single-thread apartment (STA).
 123         // [-or-] CoInitialize(NULL);
 124         // [-or-] CoCreateInstance(NULL);
 125         CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 126
 127         // Define vtMissing for optional parameters in some calls.
 128         VARIANT vtMissing;
 129         vtMissing.vt = VT_EMPTY;
 130
 131
 132         /////////////////////////////////////////////////////////////////////////
 133         // Start Microsoft Outlook and log on with your profile.
 134         //
 135
 136         // Get CLSID of the server
 137
 138         CLSID clsid;
 139         HRESULT hr;
 140
 141         // Option 1. Get CLSID from ProgID using CLSIDFromProgID.
 142         LPCOLESTR progID = L"Outlook.Application";
 143         hr = CLSIDFromProgID(progID, &clsid);
 144         if (FAILED(hr))
 145         {
 146                 wprintf(L"CLSIDFromProgID(\"%s\") failed w/err 0x%08lx\n", progID, hr);
 147                 return 1;
 148         }
 149         // Option 2. Build the CLSID directly.
 150         /*const IID CLSID_Application =
 151         {0x0006F03A,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
 152         clsid = CLSID_Application;*/
 153
 154         // Start the server and get the IDispatch interface
 155
 156         IDispatch *pOutlookApp = NULL;
 157         hr = CoCreateInstance(          // [-or-] CoCreateInstanceEx, CoGetObject
 158                 clsid,                                  // CLSID of the server
 159                 NULL,
 160                 CLSCTX_LOCAL_SERVER,    // Outlook.Application is a local server
 161                 IID_IDispatch,                  // Query the IDispatch interface
 162                 (void **)&pOutlookApp); // Output
 163
 164         if (FAILED(hr))
 165         {
 166                 wprintf(L"Outlook is not registered properly w/err 0x%08lx\n", hr);
 167                 return 1;
 168         }
 169
 170         _putws(L"Outlook.Application is started");
 171
 172         _putws(L"User logs on ...");
 173
 174         // Get the namespace and the logon.
 175
 176         // pNS = pOutlookApp->GetNamespace("MAPI")
 177         IDispatch *pNS = NULL;
 178         {
 179                 VARIANT x;
 180                 x.vt = VT_BSTR;
 181                 x.bstrVal = SysAllocString(L"MAPI");
 182
 183                 VARIANT result;
 184                 VariantInit(&result);
 185                 AutoWrap(DISPATCH_METHOD, &result, pOutlookApp, L"GetNamespace", 1, x);
 186                 pNS = result.pdispVal;
 187
 188                 VariantClear(&x);
 189         }
 190
 191         // Log on by using a dialog box to choose the profile.
 192         // pNS->Logon(vtMissing, vtMissing, true, true)
 193         {
 194                 VARIANT vtShowDialog;
 195                 vtShowDialog.vt = VT_BOOL;
 196                 vtShowDialog.boolVal = VARIANT_TRUE;
 197                 VARIANT vtNewSession;
 198                 vtNewSession.vt = VT_BOOL;
 199                 vtNewSession.boolVal = VARIANT_TRUE;
 200
 201                 AutoWrap(DISPATCH_METHOD, NULL, pNS, L"Logon", 4, vtNewSession,
 202                         vtShowDialog, vtMissing, vtMissing);
 203         }
 204
 205         // Alternative logon method that uses a specific profile.
 206         // If you use this logon method, change the profile name to an
 207         // appropriate value. The second parameter of Logon is the password (if
 208         // any) associated with the profile. This parameter exists only for
 209         // backwards compatibility and for security reasons, and it is not
 210         // recommended for use.
 211         // pNS->Logon(L"YourValidProfile", vtMissing, false, true);
 212         //{
 213         //      VARIANT vtProfile;
 214         //      vtProfile.vt = VT_BSTR;
 215         //      vtProfile.bstrVal = SysAllocString(L"YourValidProfile");
 216         //      VARIANT vtShowDialog;
 217         //      vtShowDialog.vt = VT_BOOL;
 218         //      vtShowDialog.boolVal = VARIANT_TRUE;
 219         //      VARIANT vtNewSession;
 220         //      vtNewSession.vt = VT_BOOL;
 221         //      vtNewSession.boolVal = VARIANT_TRUE;
 222
 223         //      AutoWrap(DISPATCH_METHOD, NULL, pNS, L"Logon", 4, vtNewSession,
 224         //              vtShowDialog, vtMissing, vtProfile);
 225
 226         //      VariantClear(&vtProfile);
 227         //}
 228
 229         wprintf(L"Press ENTER to continue when Outlook is ready.");
 230         getwchar();
 231
 232
 233         /////////////////////////////////////////////////////////////////////////
 234         // Enumerate the contact items.
 235         //
 236
 237         _putws(L"Enumerate the contact items");
 238
 239         // pCtFolder = pNS->GetDefaultFolder(Outlook::olFolderContacts);
 240         IDispatch *pCtFolder = NULL;
 241         {
 242                 VARIANT x;
 243                 x.vt = VT_I4;
 244                 x.lVal = 10;  // Outlook::olFolderContacts
 245
 246                 VARIANT result;
 247                 VariantInit(&result);
 248                 AutoWrap(DISPATCH_METHOD, &result, pNS, L"GetDefaultFolder", 1, x);
 249                 pCtFolder = result.pdispVal;
 250         }
 251
 252         // pCts = pCtFolder->Items;
 253         IDispatch *pCts = NULL;
 254         {
 255                 VARIANT result;
 256                 VariantInit(&result);
 257                 AutoWrap(DISPATCH_PROPERTYGET, &result, pCtFolder, L"Items", 0);
 258                 pCts = result.pdispVal;
 259         }
 260
 261         // Enumerate the contact items.
 262
 263         // Get the count of items.
 264         long lCtsCount;
 265         {
 266                 VARIANT result;
 267                 VariantInit(&result);
 268                 AutoWrap(DISPATCH_PROPERTYGET, &result, pCts, L"Count", 0);
 269                 lCtsCount = result.lVal;
 270         }
 271
 272         for (long i = 1; i <= lCtsCount; i++)
 273         {
 274                 // Get the item at i
 275                 // pItem = pCts->Item(i);
 276                 IDispatch *pItem = NULL;
 277                 {
 278                         VARIANT x;
 279                         x.vt = VT_I4;
 280                         x.lVal = i;
 281
 282                         VARIANT result;
 283                         VariantInit(&result);
 284                         AutoWrap(DISPATCH_PROPERTYGET, &result, pCts, L"Item", 1, x);
 285                         pItem = result.pdispVal;
 286                 }
 287
 288                 // Attemp to QI _ContactItem
 289                 const IID IID_ContactItem =
 290                 {0x00063021,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
 291                 IDispatch *pCt = NULL;
 292                 {
 293                         hr = pItem->QueryInterface(IID_ContactItem, (void **)&pCt);
 294                         if (SUCCEEDED(hr))
 295                         {
 296                                 // pCt->Email1Address
 297                                 VARIANT vtAddress;
 298                                 VariantInit(&vtAddress);
 299                                 AutoWrap(DISPATCH_PROPERTYGET, &vtAddress, pCt,
 300                                         L"Email1Address", 0);
 301                                 wprintf(L"%s\n", (LPCWSTR)vtAddress.bstrVal);
 302                                 VariantClear(&vtAddress);
 303
 304                                 pCt->Release();
 305                         }
 306                 }
 307
 308                 // Attemp to QI _DistListItem
 309                 const IID IID_DistListItem =
 310                 {0x00063081,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
 311                 IDispatch *pDL = NULL;
 312                 {
 313                         hr = pItem->QueryInterface(IID_DistListItem, (void **)&pDL);
 314                         if (SUCCEEDED(hr))
 315                         {
 316                                 // pDL->DLName
 317                                 VARIANT vtDLName;
 318                                 VariantInit(&vtDLName);
 319                                 AutoWrap(DISPATCH_PROPERTYGET, &vtDLName, pDL, L"DLName", 0);
 320                                 wprintf(L"%s\n", (LPCWSTR)vtDLName.bstrVal);
 321                                 VariantClear(&vtDLName);
 322
 323                                 pDL->Release();
 324                         }
 325                 }
 326
 327                 // Release the interface.
 328                 pItem->Release();
 329         }
 330
 331
 332         /////////////////////////////////////////////////////////////////////////
 333         // Create and send a new mail item.
 334         //
 335
 336         _putws(L"Create and send a new mail item");
 337
 338         // pMail = pOutlookApp->CreateItem(Outlook::olMailItem);
 339         IDispatch *pMail = NULL;
 340         {
 341                 VARIANT x;
 342                 x.vt = VT_I4;
 343                 x.lVal = 0;      // Outlook::olMailItem
 344
 345                 VARIANT result;
 346                 VariantInit(&result);
 347                 AutoWrap(DISPATCH_METHOD, &result, pOutlookApp, L"CreateItem", 1, x);
 348                 pMail = result.pdispVal;
 349         }
 350
 351         // Set the properties of the email.
 352
 353         // pMail->Subject = _bstr_t(L"Feedback of All-In-One Code Framework");
 354         {
 355                 VARIANT x;
 356                 x.vt = VT_BSTR;
 357                 x.bstrVal = SysAllocString(L"Feedback of All-In-One Code Framework");
 358                 AutoWrap(DISPATCH_PROPERTYPUT, NULL, pMail, L"Subject", 1, x);
 359                 VariantClear(&x);
 360         }
 361
 362         // pMail->To = _bstr_t(L"codefxf@microsoft.com");
 363         {
 364                 VARIANT x;
 365                 x.vt = VT_BSTR;
 366                 x.bstrVal = SysAllocString(L"codefxf@microsoft.com");
 367                 AutoWrap(DISPATCH_PROPERTYPUT, NULL, pMail, L"To", 1, x);
 368                 VariantClear(&x);
 369         }
 370
 371         // pMail->HTMLBody = _bstr_t(L"<b>Feedback:</b><br />");
 372         {
 373                 VARIANT x;
 374                 x.vt = VT_BSTR;
 375                 x.bstrVal = SysAllocString(L"<b>Feedback:</b><br />");
 376                 AutoWrap(DISPATCH_PROPERTYPUT, NULL, pMail, L"HTMLBody", 1, x);
 377                 VariantClear(&x);
 378         }
 379
 380         // Displays a new Inspector object for the item and allows users to click
 381         // on the Send button to send the mail manually.
 382         // Modal = true makes the Inspector window modal.
 383         // pMail->Display(true);
 384         {
 385                 VARIANT vtModal;
 386                 vtModal.vt = VT_BOOL;
 387                 vtModal.boolVal = VARIANT_TRUE;
 388                 AutoWrap(DISPATCH_METHOD, NULL, pMail, L"Display", 1, vtModal);
 389         }
 390
 391         // [-or-]
 392
 393         // Automatically send the mail without a new Inspector window.
 394         // pMail->Send();
 395         /*AutoWrap(DISPATCH_METHOD, NULL, pMail, L"Send", 0);*/
 396
 397
 398         /////////////////////////////////////////////////////////////////////////
 399         // User logs off and quits Outlook.
 400         //
 401
 402         _putws(L"Log off and quit the Outlook application");
 403
 404         // pNS->Logoff()
 405         AutoWrap(DISPATCH_METHOD, NULL, pNS, L"Logoff", 0);
 406
 407         // pOutlookApp->Quit()
 408         AutoWrap(DISPATCH_METHOD, NULL, pOutlookApp, L"Quit", 0);
 409
 410
 411         /////////////////////////////////////////////////////////////////////
 412         // Release the COM objects.
 413         //
 414
 415         if (pMail != NULL)
 416         {
 417                 pMail->Release();
 418         }
 419         if (pCts != NULL)
 420         {
 421                 pCts->Release();
 422         }
 423         if (pCtFolder != NULL)
 424         {
 425                 pCtFolder->Release();
 426         }
 427         if (pNS != NULL)
 428         {
 429                 pNS->Release();
 430         }
 431         if (pOutlookApp != NULL)
 432         {
 433                 pOutlookApp->Release();
 434         }
 435
 436         // Uninitialize COM for this thread.
 437         CoUninitialize();
 438
 439         return 0;
 440 }